package controller

import (
	"GoTime/models"
	"GoTime/response"
	. "GoTime/utils"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"strconv"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/spf13/cast"
	"xorm.io/builder"
)

func GetFieldList(c *gin.Context) {
	var (
		fieldList []response.FieldListResponse // 用于存储场地列表的响应
		err       error                        // 用于存储可能发生的错误
		page      int                          // 当前页码
		pageSize  int                          // 每页显示的记录数
		offset    int                          // 数据库查询时的偏移量
		count     int64                        // 场地列表的总记录数
	)

	// 检查请求中是否包含驾校ID参数
	if c.Query("school_id") == "" {
		// 如果驾校ID参数为空，返回错误信息
		c.JSON(http.StatusBadRequest, gin.H{"code": 201, "msg": "请选择驾校"})
		return
	}

	// 获取当前页码，默认为0
	page = cast.ToInt(c.DefaultQuery("page", "0"))
	// 获取每页显示的记录数，默认为10
	pageSize = cast.ToInt(c.DefaultQuery("pageSize", "10"))
	// 计算数据库查询的偏移量
	offset = (page - 1) * pageSize

	// 创建一个新的查询条件构建器
	filter := builder.NewCond()
	// 添加驾校ID的查询条件
	filter = filter.And(builder.Eq{"f.school_id": c.Query("school_id")})

	// 如果请求中包含名称参数，则添加名称的模糊查询条件
	if username := c.Query("name"); username != "" {
		filter = filter.And(builder.Like{"f.name", username})
	}

	// 如果请求中包含类型参数，则添加类型的查询条件
	if types := c.Query("type"); types != "" {
		filter = filter.And(builder.Eq{"f.type": types})
	}

	// 调用GetFieldList方法获取场地列表及其总记录数
	count, fieldList, err = new(models.Field).GetFieldList(filter, pageSize, offset)

	// 如果发生错误，返回错误信息
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "获取场地列表失败", "data": err})
		return
	}

	// 如果成功获取场地列表，返回成功信息及数据
	c.JSON(http.StatusOK, gin.H{"code": 200, "msg": "获取场地列表成功", "data": gin.H{"count": count, "list": fieldList}})
	return

}

func AddField(c *gin.Context) {
	var err error
	// 创建一个新的Field模型实例
	field := new(models.Field)

	// 绑定请求参数到field模型实例，如果绑定失败，返回错误信息
	if err := c.ShouldBind(field); err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "参数错误"})
		return
	}

	// 设置field的Isused字段为"1"
	field.Isused = "1"
	// 设置field的ApprovalStatus字段为"0"
	field.ApprovalStatus = "0"
	// 设置field的RecordStatus字段为"0"
	field.RecordStatus = "0"

	// 获取数据库引擎实例
	var engine = models.Engine
	// 创建一个新的数据库会话
	var session = engine.NewSession()
	// 确保在函数结束时关闭会话
	defer session.Close()

	// 开始一个数据库事务
	if err := session.Begin(); err != nil {
		// 如果事务开始失败，返回错误信息
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "事务开始失败"})
		return
	}

	// 插入field记录到数据库，如果插入失败，回滚事务并返回错误信息
	if _, err = session.Insert(field); err != nil {
		session.Rollback()
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": err.Error()})
		return
	}

	// 提交事务
	session.Commit()

	// 如果成功添加教学区域，返回成功信息
	c.JSON(http.StatusOK, gin.H{"code": 200, "msg": "教学区域添加成功"})
	return

}

func EditField(c *gin.Context) {
	// 创建一个新的Field模型实例
	field := new(models.Field)

	// 绑定请求参数到field模型实例，如果绑定失败，返回错误信息
	if err := c.ShouldBind(field); err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "参数错误", "data": err.Error()})
		return
	}

	// 获取请求中的场地ID参数
	fieldID := c.PostForm("field_id")
	log.Println(fieldID, c.PostForm("name"))
	if fieldID == "" {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "缺少场地ID"})
		return
	}

	// 获取数据库引擎实例
	var engine = models.Engine
	// 创建一个新的数据库会话
	var session = engine.NewSession()
	// 确保在函数结束时关闭会话
	defer session.Close()

	// 开始一个数据库事务
	if err := session.Begin(); err != nil {
		// 如果事务开始失败，返回错误信息
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "事务开始失败", "data": err.Error()})
		return
	}

	// 根据场地ID更新场地信息，如果更新失败，回滚事务并返回错误信息
	if _, err := session.ID(fieldID).Update(field); err != nil {
		session.Rollback()
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "更新场地信息失败", "data": err.Error()})
		return
	}

	// 提交事务
	session.Commit()

	// 如果成功更新教学区域，返回成功信息
	c.JSON(http.StatusOK, gin.H{"code": 200, "msg": "教学区域更新成功"})
	return
}

func DeleteField(c *gin.Context) {
	var (
		fieldID  string                 // 定义一个字符串变量用于存储场地ID
		schoolId string                 // 定义一个字符串变量用于存储驾校ID
		err      error                  // 定义一个错误变量用于存储可能发生的错误
		url      string                 // 定义一个字符串变量用于存储请求地址
		reqType  int64                  // 定义一个int64变量用于存储请求类型
		retMap   map[string]interface{} // 定义一个map变量用于存储请求返回数据
	)

	// 获取请求中的场地ID参数
	if fieldID = c.Query("field_id"); fieldID == "" {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "缺少场地ID"})
		return
	}

	// 获取请求中的驾校ID参数
	if schoolId = c.Query("school_id"); schoolId == "" {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "缺少驾校ID"})
		return
	}

	// 查询指定驾校ID的驾校信息
	ok, school, err := new(models.School).GetSchoolById(cast.ToInt(schoolId))
	if err != nil || !ok {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "查询驾校信息失败"})
		return
	}

	// 获取数据库引擎实例
	var engine = models.Engine

	// 创建一个新的数据库会话
	var session = engine.NewSession()

	// 确保在函数结束时关闭会话
	defer session.Close()

	// 开始一个数据库事务
	if err := session.Begin(); err != nil {
		// 如果事务开始失败，返回错误信息
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "事务开始失败", "data": err.Error()})
		return
	}

	// 创建一个新的Field模型实例
	field := new(models.Field)

	// 通过ID查询场地信息
	if ok, err := session.ID(fieldID).Get(field); err != nil || !ok {
		session.Rollback()
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "查询场地信息失败"})
		return
	}

	// 构造请求URL
	if url, err = GetSignURL(c.PostForm("institution_code")+"-region-"+field.FieldCode, nil, reqType, school.Province, school.City); err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": err.Error()})
		return
	}

	// 根据驾校所在省份设置API请求方法
	apiMethod := "DELETE"
	shanDong := school.Province == "370000"
	if shanDong {
		apiMethod = "GET"
	}

	// 创建一个新的ApiLog结构体实例，记录API请求信息
	var api_log models.ApiLog
	api_log.Url = url
	api_log.Param = ""
	api_log.Method = apiMethod
	api_log.UserId, _ = strconv.Atoi(c.PostForm("user_id"))
	api_log.Time = time.Now()

	// 发送API请求并获取返回结果
	if retMap, err = APIReq(url, nil, apiMethod); err != nil {
		result, _ := json.Marshal(retMap)
		api_log.Result = string(result)
		api_log.Add()
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "请求失败", "data": err.Error()})
		return
	}

	result, _ := json.Marshal(retMap)
	api_log.Result = string(result)
	api_log.Add()

	// 获取返回结果中的错误码
	errorcode, _ := cast.ToIntE(retMap["errorcode"])

	if errorcode != 0 {
		// 如果错误码不为0且消息中不包含“不存在”，则返回删除失败信息
		if !strings.Contains(retMap["message"].(string), "不存在") {
			c.JSON(http.StatusOK, gin.H{"code": 201, "msg": cast.ToString(retMap["message"])})
			return
		}
	}

	// 如果驾校省份是安徽，执行特定的删除逻辑
	//if c.PostForm("province") == "340000" {
	//    school, err := new(models.School).GetSchoolById(fmt.Sprintf("%d", field.SchoolId))
	//    if err != nil {
	//        logs.ZapLogs.Error(err.Error(), zap.String("GetSchoolById", cast.ToString(field.SchoolId)))
	//    }
	//    data := map[string]interface{}{
	//        "inscode": school.InstitutionCode,
	//        "seq":     field.FieldCode,
	//    }
	//    if _, err := AnHuiServiceAPIURLRequest("regionBA/delete.do", "POST", school.InstitutionCode, data); err != nil {
	//        logs.ZapLogs.Error(err.Error(), zap.String("AnHuiServiceAPIURLRequest", "regionBA/delete.do"))
	//    }
	//}

	// 设置场地信息以标记为删除状态
	field.Isused = "0"
	field.InstitutionCode = field.FieldCode
	field.FieldCode = "--"
	field.Reason = "主动删除"

	// 根据场地ID更新场地信息，如果更新失败，回滚事务并返回错误信息
	if _, err := session.ID(fieldID).Update(field); err != nil {
		session.Rollback()
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "更新场地信息失败", "data": err.Error()})
		return
	}

	// 提交事务
	session.Commit()

	// 如果成功删除教学区域，返回成功信息
	c.JSON(http.StatusOK, gin.H{"code": 200, "msg": "教学区域删除成功"})
	return

}

func SetClosurePoint(c *gin.Context) {
	var (
		fieldID string // 定义一个字符串变量用于存储场地ID
		err     error  // 定义一个错误变量用于存储可能发生的错误
	)

	// 从POST表单中获取场地ID，如果为空则返回错误信息
	if fieldID = c.PostForm("field_id"); fieldID == "" {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "缺少场地ID"})
		return
	}

	// 获取数据库引擎实例
	var engine = models.Engine

	// 创建一个新的数据库会话
	var session = engine.NewSession()

	// 确保在函数结束时关闭会话
	defer session.Close()

	// 开始一个数据库事务，如果事务开始失败，返回错误信息
	if err := session.Begin(); err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "事务开始失败", "data": err.Error()})
		return
	}

	// 创建一个新的Field模型实例
	field := new(models.Field)

	// 通过id查询场地信息，如果查询失败或没有找到场地，回滚事务并返回错误信息
	if ok, err := session.ID(fieldID).Get(field); err != nil || !ok {
		session.Rollback()
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "查询场地信息失败"})
		return
	}

	// 检查场地的审批状态，如果已通过审批，返回提示信息
	if field.ApprovalStatus == "1" {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "该场地已通过审批，如修改需要运管审核，请联系后台人员操作"})
		return
	}

	// 定义一个切片用于存储ClosurePoint数据
	var data []*models.ClosurePoint

	// 将POST表单中的"data"字段解析为ClosurePoint切片，如果解析失败，返回错误信息
	if err = json.Unmarshal([]byte(c.DefaultPostForm("data", "[]")), &data); err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "坐标点信息格式错误"})
		return
	}

	// 打印解析后的坐标点信息
	fmt.Println(data)

	// 检查坐标点信息是否为空，如果为空，返回错误信息
	if len(data) == 0 {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "坐标点信息不能为空"})
		return
	}

	// 删除旧的围栏信息，如果操作失败，回滚事务并返回错误信息
	if _, err = session.Exec("delete from dts_closure where field_id=?", field.Id); err != nil {
		session.Rollback()
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "删除围栏失败"})
		return
	}

	// 创建一个新的围栏实例，并设置其属性
	closure := new(models.Closure)
	closure.FieldCode = fmt.Sprintf("%.5d", field.FieldCode)
	closure.FieldId = field.Id
	closure.Type = "1"
	closure.Description = ""

	// 插入新的围栏记录，如果插入失败，回滚事务并返回错误信息
	if _, err = session.Insert(closure); err != nil {
		session.Rollback()
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "创建围栏失败"})
		return
	}

	// 遍历坐标点信息切片，为每个坐标点设置围栏ID并插入到数据库中
	for _, list := range data {
		list.ClosureId = closure.Id
		if _, err = session.Insert(list); err != nil {
			session.Rollback()
			c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "创建围栏点失败"})
			return
		}
	}

	// 提交事务
	session.Commit()

	// 返回成功信息
	c.JSON(http.StatusOK, gin.H{"code": 200, "msg": "添加成功"})
	return

}

func GetLastFieldCode(c *gin.Context) {
	var (
		schoolId string       // 定义一个字符串变量用于存储学校ID
		has      bool         // 定义一个布尔变量用于存储检查结果
		field    models.Field // 定义一个Field结构体变量用于存储场地信息
	)

	// 从POST请求中获取学校ID，如果为空则返回错误信息
	if schoolId = c.Query("school_id"); schoolId == "" {
		// 如果学校ID为空，返回状态码201和错误消息
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "缺少学校ID"})
		return
	}

	// 调用CheckLastFieldCode方法检查指定学校ID的最后一个场地编码
	has, field, _ = new(models.Field).CheckLastFieldCode(schoolId)

	if has {
		// 如果存在最后一个场地编码
		if field.Id > 0 {
			// 如果场地ID大于0，说明有有效的场地信息
			code, _ := strconv.Atoi(field.FieldCode) // 将场地编码转换为整数
			fieldCode := fmt.Sprintf("%04d", code+1) // 将整数编码加1并格式化为4位字符串
			// 返回状态码200和成功消息，同时附带新的场地编码
			c.JSON(http.StatusOK, gin.H{"code": 200, "msg": "success", "data": fieldCode})
			return
		} else {
			// 如果场地ID不大于0，返回默认的场地编码"0001"
			c.JSON(http.StatusOK, gin.H{"code": 200, "msg": "success", "data": "0001"})
			return
		}
	} else {
		// 如果不存在最后一个场地编码，返回默认的场地编码"0001"
		c.JSON(http.StatusOK, gin.H{"code": 200, "msg": "success", "data": "0001"})
		return
	}

}

func GetClosurePoint(c *gin.Context) {
	var (
		schoolId string                           // 定义一个字符串变量用于存储学校ID
		fieldId  string                           // 定义一个字符串变量用于存储场地ID
		list     []*response.ClosurePointResponse // 定义一个切片变量用于存储围栏点信息
		err      error                            // 定义一个错误变量用于存储可能发生的错误
	)

	// 从GET请求中获取学校ID和场地ID，如果为空则返回错误信息
	if schoolId = c.Query("school_id"); schoolId == "" {
		// 如果学校ID为空，返回状态码201和错误消息
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "缺少学校ID"})
		return
	}
	if fieldId = c.Query("field_id"); fieldId == "" {
		// 如果场地ID为空，返回状态码201和错误消息
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "缺少场地ID"})
		return
	}

	// 调用GetClosurePoint方法获取指定学校和场地的围栏点信息
	if list, err = new(models.Field).GetClosurePoint(schoolId, fieldId); err != nil {
		// 如果获取过程中发生错误，返回状态码201和错误消息，同时附带错误详情
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "获取围栏点信息失败", "data": err.Error()})
		return
	} else {
		// 如果成功获取围栏点信息，返回状态码200和成功消息，同时附带数据列表
		c.JSON(http.StatusOK, gin.H{"code": 200, "msg": "获取成功", "data": map[string]interface{}{"list": list}})
		return
	}

}

func FieldRecord(c *gin.Context) {
	var (
		schoolId string
		fieldId  string
		reqType  int64
		url      string
		field    models.Field
		closure  models.Closure
		points   []*models.ClosurePoint
		retMap   map[string]interface{}
	)
	//获取电子围栏id
	fieldId = c.PostForm("field_id")
	if fieldId == "" {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "缺少场地ID"})
		return
	}
	schoolId = c.PostForm("school_id")
	if schoolId == "" {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "缺少学校ID"})
		return
	}
	ok, school, err := new(models.School).GetSchoolById(cast.ToInt(schoolId))
	if err != nil || !ok {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "驾校不存在"})
		return
	}
	reqType = 2
	//根据id查询教学区域信息
	if field, err = new(models.Field).GetOneFieldById(fieldId); err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "场地不存在"})
		return
	}
	//查询围栏信息
	if closure, err = new(models.Closure).GetOneClosureByFieldId(fieldId); err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "围栏不存在"})
		return
	}
	//查询围栏坐标信息
	if points, err = new(models.ClosurePoint).GetClosurePointListByClosureId(closure.Id); len(points) <= 0 {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "围栏坐标不存在"})
		return
	}
	var polygon string
	for _, v := range points {
		polygon = polygon + fmt.Sprintf("%f,%f;", v.Longitude, v.Latitude)
	}
	data := map[string]interface{}{
		"inscode":     school.InstitutionCode, //培训机构编号 "1980679413164422"
		"seq":         field.FieldCode,        //教学区域编号
		"address":     field.Address,          //教学区域地址
		"area":        field.Area,             //教学区域面积
		"type":        field.Type,             //教学区域类型
		"vehicletype": field.TrainingCarType,  //培训车型
		"polygon":     polygon,                //多边形坐标序列
		"totalvehnum": field.Totalvehnum,
		"curvehnum":   field.Curvehnum,
		"name":        field.Name,
	}
	//进行备案
	if url, err = GetSignURL("region", data, reqType, school.Province, school.City); err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "备案失败"})
		return
	}
	var apiLog models.ApiLog
	param, err := json.Marshal(data)
	apiLog.Url = url
	apiLog.Param = string(param)
	apiLog.Method = "POST"
	apiLog.Time = time.Now()
	if retMap, err = APIReq(url, data, "POST"); err != nil {
		result, _ := json.Marshal(retMap)
		apiLog.Result = string(result)
		apiLog.Add()
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "备案失败"})
		return
	}
	result, _ := json.Marshal(retMap)
	apiLog.Result = string(result)
	apiLog.Add()
	//if school.Province == "340000" {
	//	data["flag"] = 1
	//	data["baTime"] = time.Now().Format("2006-01-02 15:04:05") // regionBA/add.do
	//	if _, err := AnHuiServiceAPIURLRequest("regionBA/add.do", "POST", school.InstitutionCode, data); err != nil {
	//		// Logfile("regionBA/add.do", "log.regionBA/add.do.log")
	//		// Logfile(err, "log.regionBA/add.do.log")
	//		logs.ZapLogs.Error(err.Error())
	//	}
	//}
	fmt.Println(retMap)
	errorCode, _ := cast.ToIntE(retMap["errorcode"])
	if errorCode != 0 {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "备案失败:" + cast.ToString(retMap["errorcode"])})
		return
	}
	//备案成功后将本地数据库dts_field备案状态修改为1
	field.RecordStatus = "1"
	if !field.Update("record_status") {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "更新场地信息失败"})
		return
	}
	//发送请求到武汉签到系统
	//if province_code == "420000" {
	//	reqData := map[string]interface{}{
	//		"inscode":     school.InstitutionCode, //培训机构编号
	//		"seq":         field.FieldCode,        //教学区域编号
	//		"address":     field.Address,          //教学区域地址
	//		"area":        field.Area,             //教学区域面积
	//		"type":        cast.ToInt(field.Type), //教学区域类型
	//		"vehicletype": field.TrainingCarType,  //培训车型
	//		"polygon":     polygon,                //多边形坐标序列
	//	}
	//	if err := WuhanSignReq("region", reqData, 3, c.PostForm("province"), c.PostForm("city"), "POST"); err != nil {
	//		//return c, err
	//	}
	//}
	c.JSON(http.StatusOK, gin.H{"code": 200, "msg": "备案教学区域成功"})
}

func GetRegionReview(c *gin.Context) {
	var (
		field    models.Field           // 定义一个Field结构体变量用于存储场地信息
		url      string                 // 定义一个字符串变量用于存储请求URL
		retMap   map[string]interface{} // 定义一个map变量用于存储API返回的结果
		fieldId  string                 // 定义一个字符串变量用于存储场地ID
		schoolId string                 // 定义一个字符串变量用于存储学校ID
		err      error                  // 定义一个错误变量用于存储可能发生的错误
		reqType  int64                  // 定义一个整数变量用于存储请求类型
	)

	// 从POST请求中获取场地ID，如果为空则返回错误信息
	if fieldId = c.Query("field_id"); fieldId == "" {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "缺少场地ID"})
		return
	}

	// 从POST请求中获取学校ID，如果为空则返回错误信息
	if schoolId = c.Query("school_id"); schoolId == "" {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "缺少学校ID"})
		return
	}

	reqType = 2 // 根据ID查询教学区域信息

	// 调用GetOneFieldById方法获取指定场地ID的场地信息
	if field, err = new(models.Field).GetOneFieldById(fieldId); err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "场地不存在"})
		return
	}

	// 调用GetSchoolById方法获取指定学校ID的学校信息
	ok, school, err := new(models.School).GetSchoolById(cast.ToInt(schoolId))
	if err != nil || !ok {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "驾校不存在"})
		return
	}

	// 构造请求URL，请求数据为空
	if url, err = GetSignURL(school.InstitutionCode+"-regionreview-"+field.FieldCode, nil, reqType, school.Province, school.City); err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "获取请求地址失败"})
		return
	}

	// 初始化ApiLog结构体，记录API请求信息
	var api_log models.ApiLog
	api_log.Url = url
	api_log.Param = ""
	api_log.Method = "POST"
	api_log.Time = time.Now()

	// 发送API请求并获取返回结果
	if retMap, err = APIReq(url, nil, "GET"); err != nil {
		result, _ := json.Marshal(retMap)
		api_log.Result = string(result)
		api_log.Add()
		c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "获取失败" + cast.ToString(retMap["errorcode"])})
		return
	}

	result, _ := json.Marshal(retMap)
	api_log.Result = string(result)
	api_log.Add()

	fmt.Println(retMap)

	// 获取返回结果中的错误码
	errorcode, _ := cast.ToIntE(retMap["errorcode"])

	// 根据错误码处理不同的情况
	if errorcode != 0 {
		if strings.Contains(retMap["message"].(string), "不存在") {
			field.RecordStatus = "0"
			// 更新场地记录状态
			if !field.Update("record_status") {
				c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "更新场地信息失败"})
				return
			}
		} else if strings.Contains(retMap["message"].(string), "未审核") {
			field.ApprovalStatus = "2"
			// 更新场地审批状态
			if !field.Update("approval_status") {
				c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "更新场地信息失败"})
				return
			}
		}
	}

	// 处理API返回的数据部分
	if md, ok := retMap["data"].(map[string]interface{}); ok {
		field.ApprovalStatus = fmt.Sprint(md["flag"])
		if fmt.Sprint(md["flag"]) == "0" {
			field.ApprovalStatus = "0"
			field.Reason = ""
			// 更新场地审批状态和原因
			if !field.Update("approval_status", "reason") {
				c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "更新场地信息失败"})
				return
			}
			c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "该区已解除备案"})
			return
		} else if fmt.Sprint(md["flag"]) == "2" {
			field.ApprovalStatus = "2"
			field.Reason = ""
			// 更新场地审批状态和原因
			if !field.Update("approval_status", "reason") {
				c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "更新场地信息失败"})
				return
			}
			c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "该区域未审核"})
			return
		} else if fmt.Sprint(md["flag"]) == "4" {
			field.ApprovalStatus = "4"
			field.Reason = fmt.Sprint(md["reason"])
			// 更新场地审批状态和原因
			if !field.Update("approval_status", "reason") {
				c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "更新场地信息失败"})
				return
			}
			c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "审核不通过，原因：" + fmt.Sprint(md["reason"])})
			return
		} else if fmt.Sprint(md["flag"]) == "1" {
			field.ApprovalStatus = "1"
			field.Reason = ""
			// 更新场地审批状态和原因
			if !field.Update("approval_status", "reason") {
				c.JSON(http.StatusOK, gin.H{"code": 201, "msg": "更新场地信息失败"})
				return
			}
			c.JSON(http.StatusOK, gin.H{"code": 200, "msg": "该区域审核合格"})
			return
		}
	}

	// 如果没有在"data"中找到匹配的"flag"，返回返回结果中的消息
	c.JSON(http.StatusOK, gin.H{"code": 201, "msg": retMap["message"].(string)})
	return

}
